/*
 * CtrlAtividade.java
 * 
 * Projeto: Kruskal - SRAC
 * LEDS - Laboratório de Engenharia e Desenvolvimento de Software
 * IFES - Instituto Federal do Espírito Santo - Campus Serra.
 */
package srac.controleatividades.cci;

import java.awt.Window;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.zkoss.zk.ui.Executions;
import srac.controleatividades.cdp.*;
import srac.controleatividades.cgt.AplCadastroInterno;
import srac.controleatividades.cih.*;
import util.utilitarioExceptions.SracException;

/**
 *
 * @author Rodrigo Maia
 */
public class CtrlInterno {
    public static final int SALVAR = 0;
    public static final int EDITAR = 1;
    public static final int CONSULTAR = 2;
    
    private Window window;
    private PagEventosCategoria pagEventosCategoria;
    private PagEventosTipoAtividade pagEventosTipoAtividade;
    
    private PagEventosFuncionario pagEventosFuncionario;
    private PagEventosAluno pagEventosAluno;

    
    private AplCadastroInterno apl = AplCadastroInterno.getInstance();

    public static CtrlInterno getInstance() {
        CtrlInterno instance = (CtrlInterno) Executions.getCurrent().getSession().getAttribute("CtrlInterno");
        if (instance == null) {
            instance = new CtrlInterno();
            Executions.getCurrent().getSession().setAttribute("CtrlInterno", instance);
        }
        return instance;
    }

    public void setPagEventosTipoAtividade(PagEventosTipoAtividade pagEventosTipoAtividade) {
        this.pagEventosTipoAtividade = pagEventosTipoAtividade;
    }
    
    
    public void setPagEventosCategoria(PagEventosCategoria pagEventosCategoria) {
        this.pagEventosCategoria = pagEventosCategoria;
    }
    
    public void setPagEventosFuncionario(PagEventosFuncionario pagEventosFuncionario){
        this.pagEventosFuncionario = pagEventosFuncionario;
    }

    public void setPagEventosAluno(PagEventosAluno pagEventosAluno) {
        this.pagEventosAluno = pagEventosAluno;
    }
    
    
    
    /**
     * Inclui uma nova Categoria
     * @param args
     * @return A categoria incluida ou Null caso haja algum erro
     */
    
    public Categoria incluirCategoria(ArrayList<Object> args) {
        Categoria c = null;
        try {
            c = apl.incluirCategoria(args);
            pagEventosCategoria.addCategoria(c);
            pagEventosCategoria.setMensagemAviso("success", "Cadastro realizado com sucesso!");
        } 
        catch (Exception ex) {
            pagEventosCategoria.setMensagemAviso("error", "Erro ao cadastrar a Categoria!");
            System.err.println(ex.getMessage());
        }
        return c;
    }
    
    /**
     * Apaga a Catregoria
     * @param categoria
     * @return Verdadeiro caso seja possível apagar a Categoria ou Falso caso contrário
     */
    
    public boolean apagarCategoria(Categoria categoria){
        try {
            return apl.apagarCategoria(categoria);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return false;
        }
    }
    
    /**
     * Altera uma Categoria
     * @param args
     * @return A Categoria Alterada ou Null caso haja algum erro
     */
    
    public Categoria alterarCategoria(Categoria args) {
        Categoria c = null;
        try {
            c = apl.alterarCategoria(args);
            pagEventosCategoria.refreshCategoria(c);
            pagEventosCategoria.setMensagemAviso("success", "Cadastro editado com sucesso!");
        } catch (Exception ex) {
            pagEventosCategoria.setMensagemAviso("error", "Erro ao editar a Categoria!");
            System.err.println(ex.getMessage());
        }
        return c;
    }
    
    /**
     * Obtem todas as Categorias cadastradas
     * @return Uma lista de Categorias ou Null caso haja algum erro
     */
    
    public List<Categoria> obterCategorias() {
        try {
            return apl.obterCategorias();
        }  
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return null;
        }
    }
    
    /**
     * Abre a PagFormularioCategoria para Incluir uma nova Categoria
     */
    
    public void abrirIncluirCategoria() {
        Map map = new HashMap();
        map.put("tipo", CtrlInterno.SALVAR);
        Executions.createComponents("/PagFormularioCategoria.zul", null, map);
    }
    
    /**
     * Abre a PagFormularioCategoria para Alterar uma Categoria
     */

    public void abrirEditarCategoria(Categoria categoria) {
        Map map = new HashMap();
        map.put("tipo", CtrlInterno.EDITAR);
        map.put("obj", categoria);
        Executions.createComponents("/PagFormularioCategoria.zul", null, map);
    }
    
    /**
     * Abre a PagFormularioCategoria para Consultar uma Categoria
     */
    
    public void abrirConsultarCategoria(Categoria categoria) {
        Map map = new HashMap();
        Object put = map.put("tipo", CtrlInterno.CONSULTAR);
        map.put("obj", categoria);
        Executions.createComponents("/PagFormularioCategoria.zul", null, map);
    }
    
    /**
     * Inclui um novo Tipo Atividade
     * @param args
     * @return O Tipo Atividade incluido ou Null caso haja algum erro
     */
    
    public TipoAtividade incluirTipoAtividade(ArrayList<Object> args) {
        TipoAtividade t = null;

        
        try {
            t = apl.incluirTipoAtividade(args);
            pagEventosTipoAtividade.addTipoAtividade(t);
            pagEventosTipoAtividade.setMensagemAviso("success", "Cadastro realizado com sucesso!");
        } 
        catch (Exception ex) {
            pagEventosTipoAtividade.setMensagemAviso("error", "Erro ao cadastrar a Atividade!");
            System.err.println(ex.getMessage());
        }
        
        return t;
    }
    
    /**
     * Apaga um Tipo Atividade
     * @param tipoAtividade
     * @return Verdadeiro caso seja possível ou Falso caso contrário
     */
    
    public boolean apagarTipoAtividade(TipoAtividade tipoAtividade) {
        try {
            return apl.apagarTipoAtividade(tipoAtividade);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return false;
        }
    }
    
    /**
     * Altera um Tipo Atividade
     * @param args
     * @return O Tipo Atividade Alterado ou Null caso haja algum erro
     */
    
    public TipoAtividade alterarTipoAtividade(TipoAtividade args) {
        TipoAtividade t = null;
        try {
            t = apl.alterarTipoAtividade(args);
            pagEventosTipoAtividade.refreshTipoAtividade(t);
            pagEventosTipoAtividade.setMensagemAviso("success", "Cadastro editado com sucesso!");
        } 
        catch (Exception ex) {
            pagEventosTipoAtividade.setMensagemAviso("error", "Erro ao editar a Atividade!");
            System.err.println(ex.getMessage());
        }
        return t;
    }
    
    /**
     * Obtem todos os Tipos Atividades cadastrados 
     * @return Uma lista de Tipos Atividades ou Null caso haja algum erro
     */
    
    public List<TipoAtividade> obterTipoAtividades() {
        try {
            return apl.obterTipoAtividades();
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return null;
        }
    }
    
    /**
     * Obtem todos os Tipos Atividades cadastrados  da Categoria
     * @param c
     * @return Uma lista de Tipos Atividades ou Null caso haja algum erro
     */
    
    public List<TipoAtividade> obterTipoAtividades(Categoria c) {
        return apl.obterTipoAtividades(c);
    }
    
    /**
     * Abre a PagFormularioTipoAtividade para Incluir um novo Tipo Atividade
     */
    
    public void abrirIncluirTipoAtividade() {
        Map map = new HashMap();
        map.put("tipo", CtrlInterno.SALVAR);
        Executions.createComponents("/PagFormularioTipoAtividade.zul", null, map);
    }
    
    /**
     * Abre a PagFormularioTipoAtividade para Alterar um Tipo Atividade
     */

    public void abrirEditarTipoAtividade(TipoAtividade tipoAtividade) {
        Map map = new HashMap();
        map.put("tipo", CtrlInterno.EDITAR);
        map.put("obj", tipoAtividade);
        Executions.createComponents("/PagFormularioTipoAtividade.zul", null, map);
    }
    
    /**
     * Abre a PagFormularioTipoAtividade para Consultar um Tipo Atividade
     */
    
    public void abrirConsultarTipoAtividade(TipoAtividade tipoAtividade) {
        Map map = new HashMap();
        Object put = map.put("tipo", CtrlInterno.CONSULTAR);
        map.put("obj", tipoAtividade);
        Executions.createComponents("/PagFormularioTipoAtividade.zul", null, map);
    }
    
    /**
     * Verifica se ja existe algum tipoAtividade cadastrado com o mesmo nome ou codigo.
     * @param nome
     * @param codigo
     * @return Verdadeiro se existe ou Falso senão existe
     */
    
    public boolean verificaExistencia(String nome, Integer codigo)
    {
        try {
            return apl.verificaExistencia(nome, codigo);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return true;
        }
    }
    
    /**
     * Verifica se ja existe alguma categoria cadastrada com o mesmo nome.
     * @param nome
     * @return Verdadeiro se existe ou Falso senão existe
     * @throws Exception 
     */
    public boolean verificaExistencia(String nome)
    {
        try {
            return apl.verificaExistencia(nome);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return true;
        }
    }
    
    /* aqui começa a edição do codigo para cadastro de usuarios*/
    
    /**
     * Inclui um novo usuário
     * @param args
     * @return 
     */
    
    public Funcionario incluirFuncionario(ArrayList<Object> args) {
        Funcionario f;
        try{
            f = (Funcionario) apl.incluirFuncionario(args);
            pagEventosFuncionario.addFuncionario(f);
            pagEventosFuncionario.setMensagemAviso("success", "Cadastro realizado com sucesso!");
            return f;
        }
        catch(Exception ex)
        {
            pagEventosFuncionario.setMensagemAviso("error", "Erro ao cadastrar o Funcionário!");
            System.err.println(ex.getMessage());
        }
        return null;   
    }
    
    public Aluno incluirAluno(ArrayList<Object> args) {
        Aluno a;
        try{
            a = (Aluno) apl.incluirAluno(args);
            pagEventosAluno.addAluno(a);
            pagEventosAluno.setMensagemAviso("success", "Cadastro realizado com sucesso!");
            return a;
        }
        catch(Exception ex)
        {
            pagEventosAluno.setMensagemAviso("error", "Erro ao cadastrar o Aluno!");
            System.err.println(ex.getMessage());
        }
        return null;   
    }
    
    
    /**
     * Exlui um usuário que é um funcionário
     * @param usuario
     * @return 
     */
    public boolean apagarFuncionario(Funcionario funcionario){
        try {
            return apl.apagarFuncionario(funcionario);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return false;
        }
    }
    
    /**
     * Exclui um usuário que é um aluno
     * @param usuario
     * @return 
     */
    public boolean apagarAluno(Aluno aluno){
        try {
            return apl.apagarAluno(aluno);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return false;
        }
    }
    
    /**
     * Altera os dados de um funcionário
     * @param args
     * @return 
     */
    public Funcionario alterarFuncionario(Funcionario f) {
        try {
            f = apl.alterarFuncionario(f);
            pagEventosFuncionario.refreshFuncionario(f);
            pagEventosFuncionario.setMensagemAviso("success", "Cadastro editado com sucesso!");
            return f;
        } catch (Exception ex) {
            pagEventosFuncionario.setMensagemAviso("error", "Erro ao editar o Funcionário!");
            System.err.println(ex.getMessage());
        }
        return null;
    }
    
    /**
     * Altera os dados de um aluno
     * @param args
     * @return 
     */
    public Aluno alterarAluno(Aluno a) {
        try {
            a = apl.alterarAluno(a);
            pagEventosAluno.refreshAluno(a);
            pagEventosAluno.setMensagemAviso("success", "Cadastro editado com sucesso!");
            return a;
        } catch (Exception ex) {
            pagEventosAluno.setMensagemAviso("error", "Erro ao editar o Aluno!");
            System.err.println(ex.getMessage());
        }
        return null;
    }
    
    /**
     * Obtém uma lista de todos os usuários cadastrados
     * @return
     * @throws SracException
     * @throws Exception 
     */
    public List<Usuario> obterUsuarios() throws SracException, Exception{
        return apl.obterUsuarios();
    }
    
    /**
     * Obtém uma lista de todos os funcionários cadastrados
     * @return
     * @throws SracException
     * @throws Exception 
     */
    public List<Funcionario> obterFuncionarios() throws SracException, Exception{
        return apl.obterFuncionario();
    }
    
    /**
     * Obtém uma lista de todos os alunos cadastrados
     * @return
     * @throws SracException
     * @throws Exception 
     */
    public List<Aluno> obterAlunos() throws SracException, Exception{
        return apl.obterAluno();
    }
    
    /**
     * Abre a PagFormularioFuncionario para Incluir um novo Funcionario
     */
    public void abrirIncluirFuncionario() {
        Map map = new HashMap();
        map.put("tipo", CtrlInterno.SALVAR);
        Executions.createComponents("/PagFormularioFuncionario.zul", null, map);
    }
    
    /**
     * Abre a PagFormularioAluno para Incluir um novo Aluno
     */
    public void abrirIncluirAluno() {
        Map map = new HashMap();
        map.put("tipo", CtrlInterno.SALVAR);
        Executions.createComponents("/PagFormularioAluno.zul", null, map);
    }
    
    /**
     * Abre a PagFormularioFuncionario para Alterar um funcionario
     * @param funcionario 
     */
    public void abrirEditarFuncionario(Funcionario funcionario) {
        Map map = new HashMap();
        map.put("tipo", CtrlInterno.EDITAR);
        map.put("obj", funcionario);
        Executions.createComponents("/PagFormularioFuncionario.zul", null, map);
    }
    
    /**
     * Abre a PagFormularioCategoria para Alterar um Aluno
     * @param aluno 
     */
    public void abrirEditarAluno(Aluno aluno) {
        Map map = new HashMap();
        map.put("tipo", CtrlInterno.EDITAR);
        map.put("obj", aluno);
        Executions.createComponents("/PagFormularioAluno.zul", null, map);
    }
    
    /**
     * Abre a PagFormularioFuncionario para Consultar um funcionario
     * @param funcionario 
     */
    public void abrirConsultarFuncionario(Funcionario funcionario) {
        Map map = new HashMap();
        map.put("tipo", CtrlInterno.CONSULTAR);
        map.put("obj", funcionario);
        Executions.createComponents("/PagFormularioFuncionario.zul", null, map);
    }
    
    /**
     * Abre a PagFormularioAluno para Consultar um Aluno
     * @param aluno 
     */
    public void abrirConsultarAluno(Aluno aluno) {
        Map map = new HashMap();
        map.put("tipo", CtrlInterno.CONSULTAR);
        map.put("obj", aluno);
        Executions.createComponents("/PagFormularioAluno.zul", null, map);
    }
    
    /**
     * Verifica a existência de um usuário com o mesmo login, matricula ou siape.
     * @param login
     * @param matOuSiape
     * @param tipoUsuario
     * @return 
     */
    public boolean verificaExistenciaUsuario(String matOuSiape)
    {
        try {
            return apl.verificaExistenciaUsuario(matOuSiape);
        } 
        catch (Exception ex) {
            System.err.println(ex.getMessage());
            return true;
        }
    }
    
    public void ativarDesativarUsuario(Usuario u, boolean b)
    {
        try {
            apl.ativarDesativarUsuario(u, b);
        } catch (Exception ex) {
            System.err.println(ex);
        }
    }
    
    
    
}